use super::crypt_algid::CRYPT_MD_AlgId;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_Data {
    pub data: *mut u8,
    pub len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_Data"][::std::mem::size_of::<CRYPT_Data>() - 16usize];
    ["Alignment of CRYPT_Data"][::std::mem::align_of::<CRYPT_Data>() - 8usize];
    ["Offset of field: CRYPT_Data::data"][::std::mem::offset_of!(CRYPT_Data, data) - 0usize];
    ["Offset of field: CRYPT_Data::len"][::std::mem::offset_of!(CRYPT_Data, len) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_ConstData {
    pub data: *const u8,
    pub len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_ConstData"][::std::mem::size_of::<CRYPT_ConstData>() - 16usize];
    ["Alignment of CRYPT_ConstData"][::std::mem::align_of::<CRYPT_ConstData>() - 8usize];
    ["Offset of field: CRYPT_ConstData::data"]
        [::std::mem::offset_of!(CRYPT_ConstData, data) - 0usize];
    ["Offset of field: CRYPT_ConstData::len"]
        [::std::mem::offset_of!(CRYPT_ConstData, len) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_Range {
    pub min: u32,
    pub max: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_Range"][::std::mem::size_of::<CRYPT_Range>() - 8usize];
    ["Alignment of CRYPT_Range"][::std::mem::align_of::<CRYPT_Range>() - 4usize];
    ["Offset of field: CRYPT_Range::min"][::std::mem::offset_of!(CRYPT_Range, min) - 0usize];
    ["Offset of field: CRYPT_Range::max"][::std::mem::offset_of!(CRYPT_Range, max) - 4usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RSA_PkcsV15Para {
    pub mdId: CRYPT_MD_AlgId,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RSA_PkcsV15Para"][::std::mem::size_of::<CRYPT_RSA_PkcsV15Para>() - 4usize];
    ["Alignment of CRYPT_RSA_PkcsV15Para"]
        [::std::mem::align_of::<CRYPT_RSA_PkcsV15Para>() - 4usize];
    ["Offset of field: CRYPT_RSA_PkcsV15Para::mdId"]
        [::std::mem::offset_of!(CRYPT_RSA_PkcsV15Para, mdId) - 0usize];
};
pub const CRYPT_RSA_SALTLEN_TYPE_HASHLEN: CRYPT_RSA_SaltLenType = -1;
pub const CRYPT_RSA_SALTLEN_TYPE_MAXLEN: CRYPT_RSA_SaltLenType = -2;
pub const CRYPT_RSA_SALTLEN_TYPE_AUTOLEN: CRYPT_RSA_SaltLenType = -3;
pub type CRYPT_RSA_SaltLenType = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RSA_PssPara {
    pub saltLen: i32,
    pub mdId: CRYPT_MD_AlgId,
    pub mgfId: CRYPT_MD_AlgId,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RSA_PssPara"][::std::mem::size_of::<CRYPT_RSA_PssPara>() - 12usize];
    ["Alignment of CRYPT_RSA_PssPara"][::std::mem::align_of::<CRYPT_RSA_PssPara>() - 4usize];
    ["Offset of field: CRYPT_RSA_PssPara::saltLen"]
        [::std::mem::offset_of!(CRYPT_RSA_PssPara, saltLen) - 0usize];
    ["Offset of field: CRYPT_RSA_PssPara::mdId"]
        [::std::mem::offset_of!(CRYPT_RSA_PssPara, mdId) - 4usize];
    ["Offset of field: CRYPT_RSA_PssPara::mgfId"]
        [::std::mem::offset_of!(CRYPT_RSA_PssPara, mgfId) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RSA_OaepPara {
    pub mdId: CRYPT_MD_AlgId,
    pub mgfId: CRYPT_MD_AlgId,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RSA_OaepPara"][::std::mem::size_of::<CRYPT_RSA_OaepPara>() - 8usize];
    ["Alignment of CRYPT_RSA_OaepPara"][::std::mem::align_of::<CRYPT_RSA_OaepPara>() - 4usize];
    ["Offset of field: CRYPT_RSA_OaepPara::mdId"]
        [::std::mem::offset_of!(CRYPT_RSA_OaepPara, mdId) - 0usize];
    ["Offset of field: CRYPT_RSA_OaepPara::mgfId"]
        [::std::mem::offset_of!(CRYPT_RSA_OaepPara, mgfId) - 4usize];
};
pub const CRYPT_RSA_BLINDING: CRYPT_RSA_Flag = 1;
pub const CRYPT_RSA_BSSA: CRYPT_RSA_Flag = 2;
pub const CRYPT_RSA_MAXFLAG: CRYPT_RSA_Flag = 3;
pub type CRYPT_RSA_Flag = ::std::os::raw::c_uint;
pub const CRYPT_ECC_PRIKEY_NO_PUBKEY: CRYPT_ECC_Flag = 2;
pub const CRYPT_ECC_MAXFLAG: CRYPT_ECC_Flag = 3;
pub type CRYPT_ECC_Flag = ::std::os::raw::c_uint;
pub const CRYPT_DH_NO_PADZERO: CRYPT_DH_Flag = 1;
pub const CRYPT_DH_MAXFLAG: CRYPT_DH_Flag = 2;
pub type CRYPT_DH_Flag = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RsaPrv {
    pub d: *mut u8,
    pub n: *mut u8,
    pub p: *mut u8,
    pub q: *mut u8,
    pub dP: *mut u8,
    pub dQ: *mut u8,
    pub qInv: *mut u8,
    pub e: *mut u8,
    pub dLen: u32,
    pub nLen: u32,
    pub pLen: u32,
    pub qLen: u32,
    pub dPLen: u32,
    pub dQLen: u32,
    pub qInvLen: u32,
    pub eLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RsaPrv"][::std::mem::size_of::<CRYPT_RsaPrv>() - 96usize];
    ["Alignment of CRYPT_RsaPrv"][::std::mem::align_of::<CRYPT_RsaPrv>() - 8usize];
    ["Offset of field: CRYPT_RsaPrv::d"][::std::mem::offset_of!(CRYPT_RsaPrv, d) - 0usize];
    ["Offset of field: CRYPT_RsaPrv::n"][::std::mem::offset_of!(CRYPT_RsaPrv, n) - 8usize];
    ["Offset of field: CRYPT_RsaPrv::p"][::std::mem::offset_of!(CRYPT_RsaPrv, p) - 16usize];
    ["Offset of field: CRYPT_RsaPrv::q"][::std::mem::offset_of!(CRYPT_RsaPrv, q) - 24usize];
    ["Offset of field: CRYPT_RsaPrv::dP"][::std::mem::offset_of!(CRYPT_RsaPrv, dP) - 32usize];
    ["Offset of field: CRYPT_RsaPrv::dQ"][::std::mem::offset_of!(CRYPT_RsaPrv, dQ) - 40usize];
    ["Offset of field: CRYPT_RsaPrv::qInv"][::std::mem::offset_of!(CRYPT_RsaPrv, qInv) - 48usize];
    ["Offset of field: CRYPT_RsaPrv::e"][::std::mem::offset_of!(CRYPT_RsaPrv, e) - 56usize];
    ["Offset of field: CRYPT_RsaPrv::dLen"][::std::mem::offset_of!(CRYPT_RsaPrv, dLen) - 64usize];
    ["Offset of field: CRYPT_RsaPrv::nLen"][::std::mem::offset_of!(CRYPT_RsaPrv, nLen) - 68usize];
    ["Offset of field: CRYPT_RsaPrv::pLen"][::std::mem::offset_of!(CRYPT_RsaPrv, pLen) - 72usize];
    ["Offset of field: CRYPT_RsaPrv::qLen"][::std::mem::offset_of!(CRYPT_RsaPrv, qLen) - 76usize];
    ["Offset of field: CRYPT_RsaPrv::dPLen"][::std::mem::offset_of!(CRYPT_RsaPrv, dPLen) - 80usize];
    ["Offset of field: CRYPT_RsaPrv::dQLen"][::std::mem::offset_of!(CRYPT_RsaPrv, dQLen) - 84usize];
    ["Offset of field: CRYPT_RsaPrv::qInvLen"]
        [::std::mem::offset_of!(CRYPT_RsaPrv, qInvLen) - 88usize];
    ["Offset of field: CRYPT_RsaPrv::eLen"][::std::mem::offset_of!(CRYPT_RsaPrv, eLen) - 92usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EccPara {
    pub p: *mut u8,
    pub a: *mut u8,
    pub b: *mut u8,
    pub n: *mut u8,
    pub h: *mut u8,
    pub x: *mut u8,
    pub y: *mut u8,
    pub pLen: u32,
    pub aLen: u32,
    pub bLen: u32,
    pub nLen: u32,
    pub hLen: u32,
    pub xLen: u32,
    pub yLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EccPara"][::std::mem::size_of::<CRYPT_EccPara>() - 88usize];
    ["Alignment of CRYPT_EccPara"][::std::mem::align_of::<CRYPT_EccPara>() - 8usize];
    ["Offset of field: CRYPT_EccPara::p"][::std::mem::offset_of!(CRYPT_EccPara, p) - 0usize];
    ["Offset of field: CRYPT_EccPara::a"][::std::mem::offset_of!(CRYPT_EccPara, a) - 8usize];
    ["Offset of field: CRYPT_EccPara::b"][::std::mem::offset_of!(CRYPT_EccPara, b) - 16usize];
    ["Offset of field: CRYPT_EccPara::n"][::std::mem::offset_of!(CRYPT_EccPara, n) - 24usize];
    ["Offset of field: CRYPT_EccPara::h"][::std::mem::offset_of!(CRYPT_EccPara, h) - 32usize];
    ["Offset of field: CRYPT_EccPara::x"][::std::mem::offset_of!(CRYPT_EccPara, x) - 40usize];
    ["Offset of field: CRYPT_EccPara::y"][::std::mem::offset_of!(CRYPT_EccPara, y) - 48usize];
    ["Offset of field: CRYPT_EccPara::pLen"][::std::mem::offset_of!(CRYPT_EccPara, pLen) - 56usize];
    ["Offset of field: CRYPT_EccPara::aLen"][::std::mem::offset_of!(CRYPT_EccPara, aLen) - 60usize];
    ["Offset of field: CRYPT_EccPara::bLen"][::std::mem::offset_of!(CRYPT_EccPara, bLen) - 64usize];
    ["Offset of field: CRYPT_EccPara::nLen"][::std::mem::offset_of!(CRYPT_EccPara, nLen) - 68usize];
    ["Offset of field: CRYPT_EccPara::hLen"][::std::mem::offset_of!(CRYPT_EccPara, hLen) - 72usize];
    ["Offset of field: CRYPT_EccPara::xLen"][::std::mem::offset_of!(CRYPT_EccPara, xLen) - 76usize];
    ["Offset of field: CRYPT_EccPara::yLen"][::std::mem::offset_of!(CRYPT_EccPara, yLen) - 80usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_PaillierPrv {
    pub n: *mut u8,
    pub lambda: *mut u8,
    pub mu: *mut u8,
    pub n2: *mut u8,
    pub nLen: u32,
    pub lambdaLen: u32,
    pub muLen: u32,
    pub n2Len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_PaillierPrv"][::std::mem::size_of::<CRYPT_PaillierPrv>() - 48usize];
    ["Alignment of CRYPT_PaillierPrv"][::std::mem::align_of::<CRYPT_PaillierPrv>() - 8usize];
    ["Offset of field: CRYPT_PaillierPrv::n"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, n) - 0usize];
    ["Offset of field: CRYPT_PaillierPrv::lambda"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, lambda) - 8usize];
    ["Offset of field: CRYPT_PaillierPrv::mu"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, mu) - 16usize];
    ["Offset of field: CRYPT_PaillierPrv::n2"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, n2) - 24usize];
    ["Offset of field: CRYPT_PaillierPrv::nLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, nLen) - 32usize];
    ["Offset of field: CRYPT_PaillierPrv::lambdaLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, lambdaLen) - 36usize];
    ["Offset of field: CRYPT_PaillierPrv::muLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, muLen) - 40usize];
    ["Offset of field: CRYPT_PaillierPrv::n2Len"]
        [::std::mem::offset_of!(CRYPT_PaillierPrv, n2Len) - 44usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EAL_NsMethod {
    pub para: *mut ::std::os::raw::c_void,
    pub init: ::std::option::Option<
        unsafe extern "C" fn(para: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void,
    >,
    pub read: ::std::option::Option<
        unsafe extern "C" fn(
            ctx: *mut ::std::os::raw::c_void,
            timeout: u32,
            buf: *mut u8,
            bufLen: u32,
        ) -> i32,
    >,
    pub deinit: ::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void)>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EAL_NsMethod"][::std::mem::size_of::<CRYPT_EAL_NsMethod>() - 32usize];
    ["Alignment of CRYPT_EAL_NsMethod"][::std::mem::align_of::<CRYPT_EAL_NsMethod>() - 8usize];
    ["Offset of field: CRYPT_EAL_NsMethod::para"]
        [::std::mem::offset_of!(CRYPT_EAL_NsMethod, para) - 0usize];
    ["Offset of field: CRYPT_EAL_NsMethod::init"]
        [::std::mem::offset_of!(CRYPT_EAL_NsMethod, init) - 8usize];
    ["Offset of field: CRYPT_EAL_NsMethod::read"]
        [::std::mem::offset_of!(CRYPT_EAL_NsMethod, read) - 16usize];
    ["Offset of field: CRYPT_EAL_NsMethod::deinit"]
        [::std::mem::offset_of!(CRYPT_EAL_NsMethod, deinit) - 24usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EAL_NsTestPara {
    pub rctCutoff: u32,
    pub aptCutoff: u32,
    pub aptWinSize: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EAL_NsTestPara"][::std::mem::size_of::<CRYPT_EAL_NsTestPara>() - 12usize];
    ["Alignment of CRYPT_EAL_NsTestPara"][::std::mem::align_of::<CRYPT_EAL_NsTestPara>() - 4usize];
    ["Offset of field: CRYPT_EAL_NsTestPara::rctCutoff"]
        [::std::mem::offset_of!(CRYPT_EAL_NsTestPara, rctCutoff) - 0usize];
    ["Offset of field: CRYPT_EAL_NsTestPara::aptCutoff"]
        [::std::mem::offset_of!(CRYPT_EAL_NsTestPara, aptCutoff) - 4usize];
    ["Offset of field: CRYPT_EAL_NsTestPara::aptWinSize"]
        [::std::mem::offset_of!(CRYPT_EAL_NsTestPara, aptWinSize) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EAL_NsPara {
    pub name: *const ::std::os::raw::c_char,
    pub autoTest: bool,
    pub minEntropy: u32,
    pub nsMeth: CRYPT_EAL_NsMethod,
    pub nsPara: CRYPT_EAL_NsTestPara,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EAL_NsPara"][::std::mem::size_of::<CRYPT_EAL_NsPara>() - 64usize];
    ["Alignment of CRYPT_EAL_NsPara"][::std::mem::align_of::<CRYPT_EAL_NsPara>() - 8usize];
    ["Offset of field: CRYPT_EAL_NsPara::name"]
        [::std::mem::offset_of!(CRYPT_EAL_NsPara, name) - 0usize];
    ["Offset of field: CRYPT_EAL_NsPara::autoTest"]
        [::std::mem::offset_of!(CRYPT_EAL_NsPara, autoTest) - 8usize];
    ["Offset of field: CRYPT_EAL_NsPara::minEntropy"]
        [::std::mem::offset_of!(CRYPT_EAL_NsPara, minEntropy) - 12usize];
    ["Offset of field: CRYPT_EAL_NsPara::nsMeth"]
        [::std::mem::offset_of!(CRYPT_EAL_NsPara, nsMeth) - 16usize];
    ["Offset of field: CRYPT_EAL_NsPara::nsPara"]
        [::std::mem::offset_of!(CRYPT_EAL_NsPara, nsPara) - 48usize];
};
pub type CRYPT_EAL_EntropyGet = ::std::option::Option<
    unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, buf: *mut u8, bufLen: u32) -> u32,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EAL_EsPara {
    pub isPhysical: bool,
    pub minEntropy: u32,
    pub entropyCtx: *mut ::std::os::raw::c_void,
    pub entropyGet: CRYPT_EAL_EntropyGet,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EAL_EsPara"][::std::mem::size_of::<CRYPT_EAL_EsPara>() - 24usize];
    ["Alignment of CRYPT_EAL_EsPara"][::std::mem::align_of::<CRYPT_EAL_EsPara>() - 8usize];
    ["Offset of field: CRYPT_EAL_EsPara::isPhysical"]
        [::std::mem::offset_of!(CRYPT_EAL_EsPara, isPhysical) - 0usize];
    ["Offset of field: CRYPT_EAL_EsPara::minEntropy"]
        [::std::mem::offset_of!(CRYPT_EAL_EsPara, minEntropy) - 4usize];
    ["Offset of field: CRYPT_EAL_EsPara::entropyCtx"]
        [::std::mem::offset_of!(CRYPT_EAL_EsPara, entropyCtx) - 8usize];
    ["Offset of field: CRYPT_EAL_EsPara::entropyGet"]
        [::std::mem::offset_of!(CRYPT_EAL_EsPara, entropyGet) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_ElGamalPrv {
    pub p: *mut u8,
    pub g: *mut u8,
    pub x: *mut u8,
    pub pLen: u32,
    pub gLen: u32,
    pub xLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_ElGamalPrv"][::std::mem::size_of::<CRYPT_ElGamalPrv>() - 40usize];
    ["Alignment of CRYPT_ElGamalPrv"][::std::mem::align_of::<CRYPT_ElGamalPrv>() - 8usize];
    ["Offset of field: CRYPT_ElGamalPrv::p"][::std::mem::offset_of!(CRYPT_ElGamalPrv, p) - 0usize];
    ["Offset of field: CRYPT_ElGamalPrv::g"][::std::mem::offset_of!(CRYPT_ElGamalPrv, g) - 8usize];
    ["Offset of field: CRYPT_ElGamalPrv::x"][::std::mem::offset_of!(CRYPT_ElGamalPrv, x) - 16usize];
    ["Offset of field: CRYPT_ElGamalPrv::pLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPrv, pLen) - 24usize];
    ["Offset of field: CRYPT_ElGamalPrv::gLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPrv, gLen) - 28usize];
    ["Offset of field: CRYPT_ElGamalPrv::xLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPrv, xLen) - 32usize];
};
pub type CRYPT_DsaPrv = CRYPT_Data;
pub type CRYPT_EccPrv = CRYPT_Data;
pub type CRYPT_EcdsaPrv = CRYPT_Data;
pub type CRYPT_Sm2Prv = CRYPT_Data;
pub type CRYPT_DhPrv = CRYPT_Data;
pub type CRYPT_EcdhPrv = CRYPT_Data;
pub type CRYPT_Curve25519Prv = CRYPT_Data;
pub type CRYPT_KemDecapsKey = CRYPT_Data;
pub type CRYPT_MlDsaPrv = CRYPT_Data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RsaPub {
    pub e: *mut u8,
    pub n: *mut u8,
    pub eLen: u32,
    pub nLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RsaPub"][::std::mem::size_of::<CRYPT_RsaPub>() - 24usize];
    ["Alignment of CRYPT_RsaPub"][::std::mem::align_of::<CRYPT_RsaPub>() - 8usize];
    ["Offset of field: CRYPT_RsaPub::e"][::std::mem::offset_of!(CRYPT_RsaPub, e) - 0usize];
    ["Offset of field: CRYPT_RsaPub::n"][::std::mem::offset_of!(CRYPT_RsaPub, n) - 8usize];
    ["Offset of field: CRYPT_RsaPub::eLen"][::std::mem::offset_of!(CRYPT_RsaPub, eLen) - 16usize];
    ["Offset of field: CRYPT_RsaPub::nLen"][::std::mem::offset_of!(CRYPT_RsaPub, nLen) - 20usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_PaillierPub {
    pub n: *mut u8,
    pub g: *mut u8,
    pub n2: *mut u8,
    pub nLen: u32,
    pub gLen: u32,
    pub n2Len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_PaillierPub"][::std::mem::size_of::<CRYPT_PaillierPub>() - 40usize];
    ["Alignment of CRYPT_PaillierPub"][::std::mem::align_of::<CRYPT_PaillierPub>() - 8usize];
    ["Offset of field: CRYPT_PaillierPub::n"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, n) - 0usize];
    ["Offset of field: CRYPT_PaillierPub::g"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, g) - 8usize];
    ["Offset of field: CRYPT_PaillierPub::n2"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, n2) - 16usize];
    ["Offset of field: CRYPT_PaillierPub::nLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, nLen) - 24usize];
    ["Offset of field: CRYPT_PaillierPub::gLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, gLen) - 28usize];
    ["Offset of field: CRYPT_PaillierPub::n2Len"]
        [::std::mem::offset_of!(CRYPT_PaillierPub, n2Len) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_SlhDsaPub {
    pub seed: *mut u8,
    pub root: *mut u8,
    pub len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_SlhDsaPub"][::std::mem::size_of::<CRYPT_SlhDsaPub>() - 24usize];
    ["Alignment of CRYPT_SlhDsaPub"][::std::mem::align_of::<CRYPT_SlhDsaPub>() - 8usize];
    ["Offset of field: CRYPT_SlhDsaPub::seed"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPub, seed) - 0usize];
    ["Offset of field: CRYPT_SlhDsaPub::root"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPub, root) - 8usize];
    ["Offset of field: CRYPT_SlhDsaPub::len"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPub, len) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_SlhDsaPrv {
    pub seed: *mut u8,
    pub prf: *mut u8,
    pub pub_: CRYPT_SlhDsaPub,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_SlhDsaPrv"][::std::mem::size_of::<CRYPT_SlhDsaPrv>() - 40usize];
    ["Alignment of CRYPT_SlhDsaPrv"][::std::mem::align_of::<CRYPT_SlhDsaPrv>() - 8usize];
    ["Offset of field: CRYPT_SlhDsaPrv::seed"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPrv, seed) - 0usize];
    ["Offset of field: CRYPT_SlhDsaPrv::prf"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPrv, prf) - 8usize];
    ["Offset of field: CRYPT_SlhDsaPrv::pub_"]
        [::std::mem::offset_of!(CRYPT_SlhDsaPrv, pub_) - 16usize];
};
pub type CRYPT_XmssPub = CRYPT_SlhDsaPub;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_XmssPrv {
    pub seed: *mut u8,
    pub prf: *mut u8,
    pub index: u64,
    pub pub_: CRYPT_XmssPub,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_XmssPrv"][::std::mem::size_of::<CRYPT_XmssPrv>() - 48usize];
    ["Alignment of CRYPT_XmssPrv"][::std::mem::align_of::<CRYPT_XmssPrv>() - 8usize];
    ["Offset of field: CRYPT_XmssPrv::seed"][::std::mem::offset_of!(CRYPT_XmssPrv, seed) - 0usize];
    ["Offset of field: CRYPT_XmssPrv::prf"][::std::mem::offset_of!(CRYPT_XmssPrv, prf) - 8usize];
    ["Offset of field: CRYPT_XmssPrv::index"]
        [::std::mem::offset_of!(CRYPT_XmssPrv, index) - 16usize];
    ["Offset of field: CRYPT_XmssPrv::pub_"][::std::mem::offset_of!(CRYPT_XmssPrv, pub_) - 24usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_ElGamalPub {
    pub p: *mut u8,
    pub g: *mut u8,
    pub y: *mut u8,
    pub q: *mut u8,
    pub pLen: u32,
    pub gLen: u32,
    pub yLen: u32,
    pub qLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_ElGamalPub"][::std::mem::size_of::<CRYPT_ElGamalPub>() - 48usize];
    ["Alignment of CRYPT_ElGamalPub"][::std::mem::align_of::<CRYPT_ElGamalPub>() - 8usize];
    ["Offset of field: CRYPT_ElGamalPub::p"][::std::mem::offset_of!(CRYPT_ElGamalPub, p) - 0usize];
    ["Offset of field: CRYPT_ElGamalPub::g"][::std::mem::offset_of!(CRYPT_ElGamalPub, g) - 8usize];
    ["Offset of field: CRYPT_ElGamalPub::y"][::std::mem::offset_of!(CRYPT_ElGamalPub, y) - 16usize];
    ["Offset of field: CRYPT_ElGamalPub::q"][::std::mem::offset_of!(CRYPT_ElGamalPub, q) - 24usize];
    ["Offset of field: CRYPT_ElGamalPub::pLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPub, pLen) - 32usize];
    ["Offset of field: CRYPT_ElGamalPub::gLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPub, gLen) - 36usize];
    ["Offset of field: CRYPT_ElGamalPub::yLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPub, yLen) - 40usize];
    ["Offset of field: CRYPT_ElGamalPub::qLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPub, qLen) - 44usize];
};
pub type CRYPT_DsaPub = CRYPT_Data;
pub type CRYPT_EccPub = CRYPT_Data;
pub type CRYPT_EcdsaPub = CRYPT_Data;
pub type CRYPT_Sm2Pub = CRYPT_Data;
pub type CRYPT_DhPub = CRYPT_Data;
pub type CRYPT_EcdhPub = CRYPT_Data;
pub type CRYPT_Curve25519Pub = CRYPT_Data;
pub type CRYPT_KemEncapsKey = CRYPT_Data;
pub type CRYPT_MlDsaPub = CRYPT_Data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RsaPara {
    pub e: *mut u8,
    pub eLen: u32,
    pub bits: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RsaPara"][::std::mem::size_of::<CRYPT_RsaPara>() - 16usize];
    ["Alignment of CRYPT_RsaPara"][::std::mem::align_of::<CRYPT_RsaPara>() - 8usize];
    ["Offset of field: CRYPT_RsaPara::e"][::std::mem::offset_of!(CRYPT_RsaPara, e) - 0usize];
    ["Offset of field: CRYPT_RsaPara::eLen"][::std::mem::offset_of!(CRYPT_RsaPara, eLen) - 8usize];
    ["Offset of field: CRYPT_RsaPara::bits"][::std::mem::offset_of!(CRYPT_RsaPara, bits) - 12usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_DsaPara {
    pub p: *mut u8,
    pub q: *mut u8,
    pub g: *mut u8,
    pub pLen: u32,
    pub qLen: u32,
    pub gLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_DsaPara"][::std::mem::size_of::<CRYPT_DsaPara>() - 40usize];
    ["Alignment of CRYPT_DsaPara"][::std::mem::align_of::<CRYPT_DsaPara>() - 8usize];
    ["Offset of field: CRYPT_DsaPara::p"][::std::mem::offset_of!(CRYPT_DsaPara, p) - 0usize];
    ["Offset of field: CRYPT_DsaPara::q"][::std::mem::offset_of!(CRYPT_DsaPara, q) - 8usize];
    ["Offset of field: CRYPT_DsaPara::g"][::std::mem::offset_of!(CRYPT_DsaPara, g) - 16usize];
    ["Offset of field: CRYPT_DsaPara::pLen"][::std::mem::offset_of!(CRYPT_DsaPara, pLen) - 24usize];
    ["Offset of field: CRYPT_DsaPara::qLen"][::std::mem::offset_of!(CRYPT_DsaPara, qLen) - 28usize];
    ["Offset of field: CRYPT_DsaPara::gLen"][::std::mem::offset_of!(CRYPT_DsaPara, gLen) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_DhPara {
    pub p: *mut u8,
    pub q: *mut u8,
    pub g: *mut u8,
    pub pLen: u32,
    pub qLen: u32,
    pub gLen: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_DhPara"][::std::mem::size_of::<CRYPT_DhPara>() - 40usize];
    ["Alignment of CRYPT_DhPara"][::std::mem::align_of::<CRYPT_DhPara>() - 8usize];
    ["Offset of field: CRYPT_DhPara::p"][::std::mem::offset_of!(CRYPT_DhPara, p) - 0usize];
    ["Offset of field: CRYPT_DhPara::q"][::std::mem::offset_of!(CRYPT_DhPara, q) - 8usize];
    ["Offset of field: CRYPT_DhPara::g"][::std::mem::offset_of!(CRYPT_DhPara, g) - 16usize];
    ["Offset of field: CRYPT_DhPara::pLen"][::std::mem::offset_of!(CRYPT_DhPara, pLen) - 24usize];
    ["Offset of field: CRYPT_DhPara::qLen"][::std::mem::offset_of!(CRYPT_DhPara, qLen) - 28usize];
    ["Offset of field: CRYPT_DhPara::gLen"][::std::mem::offset_of!(CRYPT_DhPara, gLen) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_PaillierPara {
    pub p: *mut u8,
    pub q: *mut u8,
    pub pLen: u32,
    pub qLen: u32,
    pub bits: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_PaillierPara"][::std::mem::size_of::<CRYPT_PaillierPara>() - 32usize];
    ["Alignment of CRYPT_PaillierPara"][::std::mem::align_of::<CRYPT_PaillierPara>() - 8usize];
    ["Offset of field: CRYPT_PaillierPara::p"]
        [::std::mem::offset_of!(CRYPT_PaillierPara, p) - 0usize];
    ["Offset of field: CRYPT_PaillierPara::q"]
        [::std::mem::offset_of!(CRYPT_PaillierPara, q) - 8usize];
    ["Offset of field: CRYPT_PaillierPara::pLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPara, pLen) - 16usize];
    ["Offset of field: CRYPT_PaillierPara::qLen"]
        [::std::mem::offset_of!(CRYPT_PaillierPara, qLen) - 20usize];
    ["Offset of field: CRYPT_PaillierPara::bits"]
        [::std::mem::offset_of!(CRYPT_PaillierPara, bits) - 24usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_ElGamalPara {
    pub q: *mut u8,
    pub qLen: u32,
    pub bits: u32,
    pub k_bits: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_ElGamalPara"][::std::mem::size_of::<CRYPT_ElGamalPara>() - 24usize];
    ["Alignment of CRYPT_ElGamalPara"][::std::mem::align_of::<CRYPT_ElGamalPara>() - 8usize];
    ["Offset of field: CRYPT_ElGamalPara::q"]
        [::std::mem::offset_of!(CRYPT_ElGamalPara, q) - 0usize];
    ["Offset of field: CRYPT_ElGamalPara::qLen"]
        [::std::mem::offset_of!(CRYPT_ElGamalPara, qLen) - 8usize];
    ["Offset of field: CRYPT_ElGamalPara::bits"]
        [::std::mem::offset_of!(CRYPT_ElGamalPara, bits) - 12usize];
    ["Offset of field: CRYPT_ElGamalPara::k_bits"]
        [::std::mem::offset_of!(CRYPT_ElGamalPara, k_bits) - 16usize];
};
pub type CRYPT_EAL_GetEntropyCb = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        entropy: *mut CRYPT_Data,
        strength: u32,
        lenRange: *mut CRYPT_Range,
    ) -> i32,
>;
pub type CRYPT_EAL_CleanEntropyCb = ::std::option::Option<
    unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, entropy: *mut CRYPT_Data),
>;
pub type CRYPT_EAL_GetNonceCb = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        nonce: *mut CRYPT_Data,
        strength: u32,
        lenRange: *mut CRYPT_Range,
    ) -> i32,
>;
pub type CRYPT_EAL_CleanNonceCb = ::std::option::Option<
    unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, nonce: *mut CRYPT_Data),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_RandSeedMethod {
    pub getEntropy: CRYPT_EAL_GetEntropyCb,
    pub cleanEntropy: CRYPT_EAL_CleanEntropyCb,
    pub getNonce: CRYPT_EAL_GetNonceCb,
    pub cleanNonce: CRYPT_EAL_CleanNonceCb,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_RandSeedMethod"][::std::mem::size_of::<CRYPT_RandSeedMethod>() - 32usize];
    ["Alignment of CRYPT_RandSeedMethod"][::std::mem::align_of::<CRYPT_RandSeedMethod>() - 8usize];
    ["Offset of field: CRYPT_RandSeedMethod::getEntropy"]
        [::std::mem::offset_of!(CRYPT_RandSeedMethod, getEntropy) - 0usize];
    ["Offset of field: CRYPT_RandSeedMethod::cleanEntropy"]
        [::std::mem::offset_of!(CRYPT_RandSeedMethod, cleanEntropy) - 8usize];
    ["Offset of field: CRYPT_RandSeedMethod::getNonce"]
        [::std::mem::offset_of!(CRYPT_RandSeedMethod, getNonce) - 16usize];
    ["Offset of field: CRYPT_RandSeedMethod::cleanNonce"]
        [::std::mem::offset_of!(CRYPT_RandSeedMethod, cleanNonce) - 24usize];
};
pub const CRYPT_CTRL_SET_IV: CRYPT_CipherCtrl = 0;
pub const CRYPT_CTRL_GET_IV: CRYPT_CipherCtrl = 1;
pub const CRYPT_CTRL_GET_BLOCKSIZE: CRYPT_CipherCtrl = 2;
pub const CRYPT_CTRL_SET_COUNT: CRYPT_CipherCtrl = 3;
pub const CRYPT_CTRL_SET_AAD: CRYPT_CipherCtrl = 4;
pub const CRYPT_CTRL_GET_TAG: CRYPT_CipherCtrl = 5;
pub const CRYPT_CTRL_SET_TAGLEN: CRYPT_CipherCtrl = 6;
pub const CRYPT_CTRL_SET_MSGLEN: CRYPT_CipherCtrl = 7;
pub const CRYPT_CTRL_SET_FEEDBACKSIZE: CRYPT_CipherCtrl = 8;
pub const CRYPT_CTRL_GET_FEEDBACKSIZE: CRYPT_CipherCtrl = 9;
pub const CRYPT_CTRL_DES_NOKEYCHECK: CRYPT_CipherCtrl = 10;
pub const CRYPT_CTRL_SET_PADDING: CRYPT_CipherCtrl = 11;
pub const CRYPT_CTRL_GET_PADDING: CRYPT_CipherCtrl = 12;
pub const CRYPT_CTRL_REINIT_STATUS: CRYPT_CipherCtrl = 13;
pub const CRYPT_CTRL_MAX: CRYPT_CipherCtrl = 14;
pub type CRYPT_CipherCtrl = ::std::os::raw::c_uint;
pub const CRYPT_CTRL_UP_REFERENCES: CRYPT_PkeyCtrl = 0;
pub const CRYPT_CTRL_SET_PARA_BY_ID: CRYPT_PkeyCtrl = 1;
pub const CRYPT_CTRL_SET_NO_PADDING: CRYPT_PkeyCtrl = 2;
pub const CRYPT_CTRL_GET_PARA: CRYPT_PkeyCtrl = 3;
pub const CRYPT_CTRL_GET_PARAID: CRYPT_PkeyCtrl = 4;
pub const CRYPT_CTRL_GET_BITS: CRYPT_PkeyCtrl = 5;
pub const CRYPT_CTRL_GET_SIGNLEN: CRYPT_PkeyCtrl = 6;
pub const CRYPT_CTRL_GET_SECBITS: CRYPT_PkeyCtrl = 7;
pub const CRYPT_CTRL_GET_SHARED_KEY_LEN: CRYPT_PkeyCtrl = 8;
pub const CRYPT_CTRL_GET_PUBKEY_LEN: CRYPT_PkeyCtrl = 9;
pub const CRYPT_CTRL_GET_PRVKEY_LEN: CRYPT_PkeyCtrl = 10;
pub const CRYPT_CTRL_GET_CIPHERTEXT_LEN: CRYPT_PkeyCtrl = 11;
pub const CRYPT_CTRL_SET_DETERMINISTIC_FLAG: CRYPT_PkeyCtrl = 12;
pub const CRYPT_CTRL_SET_CTX_INFO: CRYPT_PkeyCtrl = 13;
pub const CRYPT_CTRL_SET_PREHASH_FLAG: CRYPT_PkeyCtrl = 14;
pub const CRYPT_CTRL_GEN_PARA: CRYPT_PkeyCtrl = 15;
pub const CRYPT_CTRL_SET_GEN_FLAG: CRYPT_PkeyCtrl = 16;
pub const CRYPT_CTRL_PCT_TEST: CRYPT_PkeyCtrl = 17;
pub const CRYPT_CTRL_CLEAN_PUB_KEY: CRYPT_PkeyCtrl = 18;
pub const CRYPT_CTRL_SET_DH_FLAG: CRYPT_PkeyCtrl = 150;
pub const CRYPT_CTRL_SET_RSA_EMSA_PKCSV15: CRYPT_PkeyCtrl = 200;
pub const CRYPT_CTRL_GET_RSA_SALT: CRYPT_PkeyCtrl = 201;
pub const CRYPT_CTRL_SET_RSA_EMSA_PSS: CRYPT_PkeyCtrl = 202;
pub const CRYPT_CTRL_SET_RSA_SALT: CRYPT_PkeyCtrl = 203;
pub const CRYPT_CTRL_SET_RSA_PADDING: CRYPT_PkeyCtrl = 204;
pub const CRYPT_CTRL_SET_RSA_RSAES_OAEP: CRYPT_PkeyCtrl = 205;
pub const CRYPT_CTRL_SET_RSA_OAEP_LABEL: CRYPT_PkeyCtrl = 206;
pub const CRYPT_CTRL_SET_RSA_FLAG: CRYPT_PkeyCtrl = 207;
pub const CRYPT_CTRL_SET_RSA_RSAES_PKCSV15: CRYPT_PkeyCtrl = 208;
pub const CRYPT_CTRL_SET_RSA_RSAES_PKCSV15_TLS: CRYPT_PkeyCtrl = 209;
pub const CRYPT_CTRL_GET_RSA_SALTLEN: CRYPT_PkeyCtrl = 210;
pub const CRYPT_CTRL_GET_RSA_PADDING: CRYPT_PkeyCtrl = 211;
pub const CRYPT_CTRL_GET_RSA_MD: CRYPT_PkeyCtrl = 212;
pub const CRYPT_CTRL_GET_RSA_MGF: CRYPT_PkeyCtrl = 213;
pub const CRYPT_CTRL_CLR_RSA_FLAG: CRYPT_PkeyCtrl = 214;
pub const CRYPT_CTRL_SET_RSA_BSSA_FACTOR_R: CRYPT_PkeyCtrl = 215;
pub const CRYPT_CTRL_SET_SM2_USER_ID: CRYPT_PkeyCtrl = 300;
pub const CRYPT_CTRL_SET_SM2_SERVER: CRYPT_PkeyCtrl = 301;
pub const CRYPT_CTRL_SET_SM2_R: CRYPT_PkeyCtrl = 302;
pub const CRYPT_CTRL_SET_SM2_RANDOM: CRYPT_PkeyCtrl = 303;
pub const CRYPT_CTRL_SET_SM2_PKG: CRYPT_PkeyCtrl = 304;
pub const CRYPT_CTRL_SET_SM2_K: CRYPT_PkeyCtrl = 305;
pub const CRYPT_CTRL_SET_ECC_POINT_FORMAT: CRYPT_PkeyCtrl = 306;
pub const CRYPT_CTRL_SET_ECC_USE_COFACTOR_MODE: CRYPT_PkeyCtrl = 307;
pub const CRYPT_CTRL_SET_ECC_FLAG: CRYPT_PkeyCtrl = 308;
pub const CRYPT_CTRL_CLR_ECC_FLAG: CRYPT_PkeyCtrl = 309;
pub const CRYPT_CTRL_GET_SM2_SEND_CHECK: CRYPT_PkeyCtrl = 310;
pub const CRYPT_CTRL_GENE_SM2_R: CRYPT_PkeyCtrl = 311;
pub const CRYPT_CTRL_SM2_DO_CHECK: CRYPT_PkeyCtrl = 312;
pub const CRYPT_CTRL_GEN_ECC_PUBLICKEY: CRYPT_PkeyCtrl = 313;
pub const CRYPT_CTRL_GET_ECC_PUB_X_BIN: CRYPT_PkeyCtrl = 314;
pub const CRYPT_CTRL_GET_ECC_PUB_Y_BIN: CRYPT_PkeyCtrl = 315;
pub const CRYPT_CTRL_GET_ECC_ORDER_BITS: CRYPT_PkeyCtrl = 316;
pub const CRYPT_CTRL_GET_ECC_NAME: CRYPT_PkeyCtrl = 317;
pub const CRYPT_CTRL_GEN_X25519_PUBLICKEY: CRYPT_PkeyCtrl = 318;
pub const CRYPT_CTRL_GET_SM2_RANDOM: CRYPT_PkeyCtrl = 319;
pub const CRYPT_CTRL_GET_ECC_FLAG: CRYPT_PkeyCtrl = 320;
pub const CRYPT_CTRL_GET_SLH_DSA_KEY_LEN: CRYPT_PkeyCtrl = 600;
pub const CRYPT_CTRL_SET_SLH_DSA_ADDRAND: CRYPT_PkeyCtrl = 601;
pub const CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG: CRYPT_PkeyCtrl = 700;
pub const CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG: CRYPT_PkeyCtrl = 701;
pub const CRYPT_CTRL_GET_MLDSA_SEED: CRYPT_PkeyCtrl = 702;
pub const CRYPT_CTRL_SET_MLDSA_PRVKEY_FORMAT: CRYPT_PkeyCtrl = 703;
pub const CRYPT_CTRL_GET_MLDSA_PRVKEY_FORMAT: CRYPT_PkeyCtrl = 704;
pub const CRYPT_CTRL_GET_XMSS_KEY_LEN: CRYPT_PkeyCtrl = 800;
pub type CRYPT_PkeyCtrl = ::std::os::raw::c_uint;
pub const CRYPT_CTRL_SET_GM_LEVEL: CRYPT_RandCtrl = 0;
pub const CRYPT_CTRL_SET_RESEED_INTERVAL: CRYPT_RandCtrl = 1;
pub const CRYPT_CTRL_SET_RESEED_TIME: CRYPT_RandCtrl = 2;
pub const CRYPT_CTRL_GET_RESEED_INTERVAL: CRYPT_RandCtrl = 3;
pub const CRYPT_CTRL_GET_RESEED_TIME: CRYPT_RandCtrl = 4;
pub const CRYPT_CTRL_SET_PREDICTION_RESISTANCE: CRYPT_RandCtrl = 5;
pub const CRYPT_CTRL_GET_WORKING_STATUS: CRYPT_RandCtrl = 6;
pub const CRYPT_CTRL_RAND_MAX: CRYPT_RandCtrl = 255;
pub type CRYPT_RandCtrl = ::std::os::raw::c_uint;
pub const CRYPT_CTRL_SET_CBC_MAC_PADDING: CRYPT_MacCtrl = 0;
pub const CRYPT_CTRL_GET_MACLEN: CRYPT_MacCtrl = 1;
pub const CRYPT_CTRL_MAC_MAX: CRYPT_MacCtrl = 2;
pub type CRYPT_MacCtrl = ::std::os::raw::c_uint;
pub const CRYPT_ENTROPY_SET_POOL_SIZE: CRYPT_ENTROPY_TYPE = 0;
pub const CRYPT_ENTROPY_SET_CF: CRYPT_ENTROPY_TYPE = 1;
pub const CRYPT_ENTROPY_ADD_NS: CRYPT_ENTROPY_TYPE = 2;
pub const CRYPT_ENTROPY_REMOVE_NS: CRYPT_ENTROPY_TYPE = 3;
pub const CRYPT_ENTROPY_ENABLE_TEST: CRYPT_ENTROPY_TYPE = 4;
pub const CRYPT_ENTROPY_GET_STATE: CRYPT_ENTROPY_TYPE = 5;
pub const CRYPT_ENTROPY_GET_POOL_SIZE: CRYPT_ENTROPY_TYPE = 6;
pub const CRYPT_ENTROPY_POOL_GET_CURRSIZE: CRYPT_ENTROPY_TYPE = 7;
pub const CRYPT_ENTROPY_GET_CF_SIZE: CRYPT_ENTROPY_TYPE = 8;
pub const CRYPT_ENTROPY_GATHER_ENTROPY: CRYPT_ENTROPY_TYPE = 9;
pub const CRYPT_ENTROPY_SET_LOG_CALLBACK: CRYPT_ENTROPY_TYPE = 10;
pub const CRYPT_ENTROPY_MAX: CRYPT_ENTROPY_TYPE = 11;
pub type CRYPT_ENTROPY_TYPE = ::std::os::raw::c_uint;
pub const CRYPT_PADDING_NONE: CRYPT_PaddingType = 0;
pub const CRYPT_PADDING_ZEROS: CRYPT_PaddingType = 1;
pub const CRYPT_PADDING_ISO7816: CRYPT_PaddingType = 2;
pub const CRYPT_PADDING_X923: CRYPT_PaddingType = 3;
pub const CRYPT_PADDING_PKCS5: CRYPT_PaddingType = 4;
pub const CRYPT_PADDING_PKCS7: CRYPT_PaddingType = 5;
pub const CRYPT_PADDING_MAX_COUNT: CRYPT_PaddingType = 6;
pub type CRYPT_PaddingType = ::std::os::raw::c_uint;
pub const CRYPT_EMSA_PKCSV15: CRYPT_RsaPadType = 1;
pub const CRYPT_EMSA_PSS: CRYPT_RsaPadType = 2;
pub const CRYPT_RSAES_OAEP: CRYPT_RsaPadType = 3;
pub const CRYPT_RSAES_PKCSV15: CRYPT_RsaPadType = 4;
pub const CRYPT_RSA_NO_PAD: CRYPT_RsaPadType = 5;
pub const CRYPT_RSAES_PKCSV15_TLS: CRYPT_RsaPadType = 6;
pub const CRYPT_RSA_PADDINGMAX: CRYPT_RsaPadType = 7;
pub type CRYPT_RsaPadType = ::std::os::raw::c_uint;
pub const CRYPT_EVENT_ENC: CRYPT_EVENT_TYPE = 0;
pub const CRYPT_EVENT_DEC: CRYPT_EVENT_TYPE = 1;
pub const CRYPT_EVENT_GEN: CRYPT_EVENT_TYPE = 2;
pub const CRYPT_EVENT_SIGN: CRYPT_EVENT_TYPE = 3;
pub const CRYPT_EVENT_VERIFY: CRYPT_EVENT_TYPE = 4;
pub const CRYPT_EVENT_MD: CRYPT_EVENT_TYPE = 5;
pub const CRYPT_EVENT_MAC: CRYPT_EVENT_TYPE = 6;
pub const CRYPT_EVENT_KDF: CRYPT_EVENT_TYPE = 7;
pub const CRYPT_EVENT_KEYAGGREMENT: CRYPT_EVENT_TYPE = 8;
pub const CRYPT_EVENT_RANDGEN: CRYPT_EVENT_TYPE = 9;
pub const CRYPT_EVENT_ZERO: CRYPT_EVENT_TYPE = 10;
pub const CRYPT_EVENT_ERR: CRYPT_EVENT_TYPE = 11;
pub const CRYPT_EVENT_SETSSP: CRYPT_EVENT_TYPE = 12;
pub const CRYPT_EVENT_GETSSP: CRYPT_EVENT_TYPE = 13;
pub const CRYPT_EVENT_ENCAPS: CRYPT_EVENT_TYPE = 14;
pub const CRYPT_EVENT_DECAPS: CRYPT_EVENT_TYPE = 15;
pub const CRYPT_EVENT_BLIND: CRYPT_EVENT_TYPE = 16;
pub const CRYPT_EVENT_UNBLIND: CRYPT_EVENT_TYPE = 17;
pub const CRYPT_EVENT_PARAM_CHECK: CRYPT_EVENT_TYPE = 18;
pub const CRYPT_EVENT_PCT_TEST: CRYPT_EVENT_TYPE = 19;
pub const CRYPT_EVENT_KAT_TEST: CRYPT_EVENT_TYPE = 20;
pub const CRYPT_EVENT_ES_HEALTH_TEST: CRYPT_EVENT_TYPE = 21;
pub const CRYPT_EVENT_INTEGRITY_TEST: CRYPT_EVENT_TYPE = 22;
pub const CRYPT_EVENT_GET_VERSION: CRYPT_EVENT_TYPE = 23;
pub const CRYPT_EVENT_MAX: CRYPT_EVENT_TYPE = 24;
pub type CRYPT_EVENT_TYPE = ::std::os::raw::c_uint;
pub const CRYPT_ALGO_CIPHER: CRYPT_ALGO_TYPE = 0;
pub const CRYPT_ALGO_PKEY: CRYPT_ALGO_TYPE = 1;
pub const CRYPT_ALGO_MD: CRYPT_ALGO_TYPE = 2;
pub const CRYPT_ALGO_MAC: CRYPT_ALGO_TYPE = 3;
pub const CRYPT_ALGO_KDF: CRYPT_ALGO_TYPE = 4;
pub const CRYPT_ALGO_RAND: CRYPT_ALGO_TYPE = 5;
pub type CRYPT_ALGO_TYPE = ::std::os::raw::c_uint;
pub const CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE_CRYPT_ALGO_MLDSA_PRIV_FORMAT_NOT_SET:
    CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = 0;
pub const CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE_CRYPT_ALGO_MLDSA_PRIV_FORMAT_BOTH:
    CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = 1;
pub const CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE_CRYPT_ALGO_MLDSA_PRIV_FORMAT_PRIV_ONLY:
    CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = 2;
pub const CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE_CRYPT_ALGO_MLDSA_PRIV_FORMAT_SEED_ONLY:
    CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = 3;
pub const CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE_CRYPT_ALGO_MLDSA_PRIV_FORMAT_END:
    CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = 4;
pub type CRYPT_ALGO_MLDSA_PRIV_KEY_FORMAT_TYPE = ::std::os::raw::c_uint;
pub type EventReport = ::std::option::Option<
    unsafe extern "C" fn(oper: CRYPT_EVENT_TYPE, type_: CRYPT_ALGO_TYPE, id: i32, err: i32),
>;
unsafe extern "C" {
    pub fn CRYPT_EAL_RegEventReport(func: EventReport);
}
pub const CRYPT_INFO_IS_AEAD: CRYPT_INFO_TYPE = 0;
pub const CRYPT_INFO_IS_STREAM: CRYPT_INFO_TYPE = 1;
pub const CRYPT_INFO_IV_LEN: CRYPT_INFO_TYPE = 2;
pub const CRYPT_INFO_KEY_LEN: CRYPT_INFO_TYPE = 3;
pub const CRYPT_INFO_BLOCK_LEN: CRYPT_INFO_TYPE = 4;
pub const CRYPT_INFO_MAX: CRYPT_INFO_TYPE = 5;
pub type CRYPT_INFO_TYPE = ::std::os::raw::c_uint;
pub const CRYPT_KDF_HKDF_MODE_FULL: CRYPT_HKDF_MODE = 0;
pub const CRYPT_KDF_HKDF_MODE_EXTRACT: CRYPT_HKDF_MODE = 1;
pub const CRYPT_KDF_HKDF_MODE_EXPAND: CRYPT_HKDF_MODE = 2;
pub type CRYPT_HKDF_MODE = ::std::os::raw::c_uint;
pub const CRYPT_ENCDEC_UNKNOW: CRYPT_ENCDEC_TYPE = 0;
pub const CRYPT_PRIKEY_PKCS8_UNENCRYPT: CRYPT_ENCDEC_TYPE = 1;
pub const CRYPT_PRIKEY_PKCS8_ENCRYPT: CRYPT_ENCDEC_TYPE = 2;
pub const CRYPT_PRIKEY_RSA: CRYPT_ENCDEC_TYPE = 3;
pub const CRYPT_PRIKEY_ECC: CRYPT_ENCDEC_TYPE = 4;
pub const CRYPT_PUBKEY_SUBKEY: CRYPT_ENCDEC_TYPE = 5;
pub const CRYPT_PUBKEY_RSA: CRYPT_ENCDEC_TYPE = 6;
pub const CRYPT_PUBKEY_SUBKEY_WITHOUT_SEQ: CRYPT_ENCDEC_TYPE = 7;
pub type CRYPT_ENCDEC_TYPE = ::std::os::raw::c_uint;
pub const CRYPT_DERIVE_PBKDF2: CRYPT_DERIVE_MODE = 0;
pub type CRYPT_DERIVE_MODE = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EncodeParam {
    pub deriveMode: u32,
    pub param: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EncodeParam"][::std::mem::size_of::<CRYPT_EncodeParam>() - 16usize];
    ["Alignment of CRYPT_EncodeParam"][::std::mem::align_of::<CRYPT_EncodeParam>() - 8usize];
    ["Offset of field: CRYPT_EncodeParam::deriveMode"]
        [::std::mem::offset_of!(CRYPT_EncodeParam, deriveMode) - 0usize];
    ["Offset of field: CRYPT_EncodeParam::param"]
        [::std::mem::offset_of!(CRYPT_EncodeParam, param) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_Pbkdf2Param {
    pub pbesId: u32,
    pub pbkdfId: u32,
    pub hmacId: u32,
    pub symId: u32,
    pub saltLen: u32,
    pub pwd: *mut u8,
    pub pwdLen: u32,
    pub itCnt: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_Pbkdf2Param"][::std::mem::size_of::<CRYPT_Pbkdf2Param>() - 40usize];
    ["Alignment of CRYPT_Pbkdf2Param"][::std::mem::align_of::<CRYPT_Pbkdf2Param>() - 8usize];
    ["Offset of field: CRYPT_Pbkdf2Param::pbesId"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, pbesId) - 0usize];
    ["Offset of field: CRYPT_Pbkdf2Param::pbkdfId"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, pbkdfId) - 4usize];
    ["Offset of field: CRYPT_Pbkdf2Param::hmacId"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, hmacId) - 8usize];
    ["Offset of field: CRYPT_Pbkdf2Param::symId"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, symId) - 12usize];
    ["Offset of field: CRYPT_Pbkdf2Param::saltLen"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, saltLen) - 16usize];
    ["Offset of field: CRYPT_Pbkdf2Param::pwd"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, pwd) - 24usize];
    ["Offset of field: CRYPT_Pbkdf2Param::pwdLen"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, pwdLen) - 32usize];
    ["Offset of field: CRYPT_Pbkdf2Param::itCnt"]
        [::std::mem::offset_of!(CRYPT_Pbkdf2Param, itCnt) - 36usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EAL_LibCtx {
    _unused: [u8; 0],
}
pub type CRYPT_EAL_LibCtx = EAL_LibCtx;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EAL_ProviderMgrCtx {
    _unused: [u8; 0],
}
pub type CRYPT_EAL_ProvMgrCtx = EAL_ProviderMgrCtx;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CRYPT_EAL_Func {
    pub id: i32,
    pub func: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of CRYPT_EAL_Func"][::std::mem::size_of::<CRYPT_EAL_Func>() - 16usize];
    ["Alignment of CRYPT_EAL_Func"][::std::mem::align_of::<CRYPT_EAL_Func>() - 8usize];
    ["Offset of field: CRYPT_EAL_Func::id"][::std::mem::offset_of!(CRYPT_EAL_Func, id) - 0usize];
    ["Offset of field: CRYPT_EAL_Func::func"]
        [::std::mem::offset_of!(CRYPT_EAL_Func, func) - 8usize];
};
pub const CRYPT_CMVP_PROVIDER_SELFTEST: CRYPT_CMVP_SELFTEST_AlgId = 1;
pub type CRYPT_CMVP_SELFTEST_AlgId = ::std::os::raw::c_uint;
